home *** CD-ROM | disk | FTP | other *** search
/ Aminet 37 / Aminet 37 (2000)(Schatztruhe)[!][Jun 2000].iso / Aminet / dev / lang / sofa.lha / sofa / smalleiffel / lib_se / run_feature_8.e < prev    next >
Text File  |  2000-03-25  |  9KB  |  348 lines
  1. --          This file is part of SmallEiffel The GNU Eiffel Compiler.
  2. --          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
  3. --            Dominique COLNET and Suzanne COLLIN - colnet@loria.fr
  4. --                       http://SmallEiffel.loria.fr
  5. -- SmallEiffel is  free  software;  you can  redistribute it and/or modify it
  6. -- under the terms of the GNU General Public License as published by the Free
  7. -- Software  Foundation;  either  version  2, or (at your option)  any  later
  8. -- version. SmallEiffel is distributed in the hope that it will be useful,but
  9. -- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10. -- or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU General Public License
  11. -- for  more  details.  You  should  have  received a copy of the GNU General
  12. -- Public  License  along  with  SmallEiffel;  see the file COPYING.  If not,
  13. -- write to the  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14. -- Boston, MA 02111-1307, USA.
  15. --
  16. class RUN_FEATURE_8
  17.  
  18. inherit RUN_FEATURE;
  19.  
  20. creation make
  21.  
  22. feature
  23.  
  24.    base_feature: EXTERNAL_FUNCTION;
  25.  
  26.    static_value_mem: INTEGER;
  27.  
  28.    arguments: FORMAL_ARG_LIST;
  29.  
  30.    result_type: TYPE;
  31.  
  32.    require_assertion: RUN_REQUIRE;
  33.  
  34.    ensure_assertion: E_ENSURE;
  35.  
  36.    is_deferred: BOOLEAN is false;
  37.  
  38.    is_pre_computable: BOOLEAN is false;
  39.  
  40.    can_be_dropped: BOOLEAN is false;
  41.  
  42.    is_once_procedure: BOOLEAN is false;
  43.  
  44.    is_once_function: BOOLEAN is false;
  45.  
  46.    arg_count: INTEGER is
  47.       do
  48.          if arguments /= Void then
  49.             Result := arguments.count;
  50.          end;
  51.       end;
  52.  
  53.    local_vars: LOCAL_VAR_LIST is
  54.       do
  55.       end;
  56.  
  57.    routine_body: COMPOUND is
  58.       do
  59.       end;
  60.  
  61.    rescue_compound: COMPOUND is
  62.       do
  63.       end;
  64.  
  65.    afd_check is
  66.       do
  67.          routine_afd_check;
  68.       end;
  69.  
  70.    is_static: BOOLEAN is
  71.       local
  72.          n: STRING;
  73.          type_bit: TYPE_BIT;
  74.       do
  75.          n := name.to_string;
  76.          if as_is_expanded_type = n then
  77.             Result := true;
  78.             if current_type.is_expanded then
  79.                static_value_mem := 1;
  80.             end;
  81.          elseif as_is_basic_expanded_type = n then
  82.             Result := true;
  83.             if current_type.is_basic_eiffel_expanded then
  84.                static_value_mem := 1;
  85.             end;
  86.          elseif as_count = n and then current_type.is_bit then
  87.             Result := true;
  88.             type_bit ?= current_type;
  89.             static_value_mem := type_bit.nb;
  90.          end;
  91.       end;
  92.  
  93.    mapping_c is
  94.       local
  95.          bf: like base_feature;
  96.          native: NATIVE;
  97.          bcn: STRING;
  98.       do
  99.          bf := base_feature;
  100.          native := bf.native;
  101.          bcn := bf.base_class.name.to_string;
  102.          native.c_mapping_function(Current,bcn,bf.first_name.to_string);
  103.       end;
  104.  
  105.    c_define is
  106.       local
  107.          bf: like base_feature;
  108.          native: NATIVE;
  109.          bcn: STRING;
  110.       do
  111.          bf := base_feature;
  112.          native := bf.native;
  113.          bcn := bf.base_class.name.to_string;
  114.          native.c_define_function(Current,bcn,bf.first_name.to_string);
  115.       end;
  116.  
  117.    mapping_jvm is
  118.       local
  119.          bf: like base_feature;
  120.          native: NATIVE;
  121.          bcn: STRING;
  122.       do
  123.          bf := base_feature;
  124.          native := bf.native;
  125.          bcn := bf.base_class.name.to_string;
  126.          native.jvm_mapping_function(Current,bcn,bf.first_name.to_string);
  127.       end;
  128.  
  129. feature {TYPE_BIT_2}
  130.  
  131.    integer_value(p: POSITION): INTEGER is
  132.       local
  133.          n: STRING;
  134.       do
  135.          n := name.to_string;
  136.          if as_integer_bits = n then
  137.             Result := Integer_bits;
  138.          elseif as_character_bits = n then
  139.             Result := Character_bits;
  140.          else
  141.             eh.add_position(p);
  142.             eh.add_position(start_position);
  143.             fatal_error(fz_iinaiv);
  144.          end;
  145.       end;
  146.  
  147. feature {RUN_CLASS}
  148.  
  149.    jvm_field_or_method is
  150.       local
  151.          bf: like base_feature;
  152.          native: NATIVE;
  153.          n, bcn: STRING;
  154.          type_bit_ref: TYPE_BIT_REF;
  155.       do
  156.          bf := base_feature;
  157.          n := bf.first_name.to_string;
  158.          type_bit_ref ?= current_type;
  159.          if type_bit_ref /= Void and then as_item = n then
  160.             jvm.add_field(Current);
  161.          else
  162.             native := base_feature.native;
  163.             bcn := bf.base_class.name.to_string;
  164.             native.jvm_add_method_for_function(Current,bcn,n);
  165.          end;
  166.       end;
  167.  
  168. feature {JVM}
  169.  
  170.    jvm_define is
  171.       local
  172.          bf: like base_feature;
  173.          native: NATIVE;
  174.          n, bcn: STRING;
  175.          type_bit_ref: TYPE_BIT_REF;
  176.          cp: like constant_pool;
  177.       do
  178.          bf := base_feature;
  179.          n := bf.first_name.to_string;
  180.          type_bit_ref ?= current_type;
  181.          if type_bit_ref /= Void and then as_item = n then
  182.             cp := constant_pool;
  183.             field_info.add(1,cp.idx_utf8(n),cp.idx_utf8(fz_a9));
  184.          else
  185.             native := bf.native;
  186.             bcn := bf.base_class.name.to_string;
  187.             native.jvm_define_function(Current,bcn,n);
  188.          end;
  189.       end;
  190.  
  191. feature {NATIVE}
  192.  
  193.    c_prototype is
  194.       do
  195.          external_prototype(base_feature);
  196.       end;
  197.  
  198. feature {NATIVE_SMALL_EIFFEL}
  199.  
  200.    c_opening is
  201.       do
  202.          define_prototype;
  203.          c_define_opening;
  204.       end;
  205.  
  206.    c_closing is
  207.       do
  208.          c_define_closing;
  209.          cpp.put_string(fz_15);
  210.          c_frame_descriptor;
  211.       end;
  212.  
  213. feature {NATIVE}
  214.  
  215.    jvm_opening is
  216.       do
  217.          method_info_start;
  218.          jvm_define_opening;
  219.       end;
  220.  
  221.    jvm_closing is
  222.       do
  223.          jvm_define_closing;
  224.          result_type.jvm_push_local(jvm_result_offset);
  225.          result_type.run_type.jvm_return_code;
  226.          method_info.finish;
  227.       end;
  228.  
  229.    jvm_closing_fast is
  230.          -- Skip ensure and assume the result is already pushed.
  231.       do
  232.          result_type.run_type.jvm_return_code;
  233.          method_info.finish;
  234.       end;
  235.  
  236. feature {CALL_PROC_CALL}
  237.  
  238.    collect_c_tmp is
  239.       do
  240.       end;
  241.  
  242. feature {ADDRESS_OF_POOL}
  243.  
  244.    address_of_c_define(caller: ADDRESS_OF) is
  245.       do
  246.       end;
  247.  
  248. feature {ADDRESS_OF}
  249.  
  250.    address_of_c_mapping is
  251.       do
  252.       end;
  253.  
  254. feature {NONE}
  255.  
  256.    tmp_string: STRING is
  257.       once
  258.          !!Result.make(80);
  259.       end;
  260.  
  261.    initialize is
  262.       local
  263.          n: STRING;
  264.          rf: RUN_FEATURE;
  265.          type_bit_ref: TYPE_BIT_REF;
  266.       do
  267.          n := base_feature.first_name.to_string;
  268.          arguments := base_feature.arguments;
  269.          type_bit_ref ?= current_type;
  270.          if type_bit_ref /= Void and then as_item = n then
  271.             result_type := type_bit_ref.type_bit;
  272.             if arguments /= Void then
  273.                if not arguments.is_runnable(current_type) then
  274.                   !!arguments.with(arguments,current_type);
  275.                end;
  276.             end;
  277.          else
  278.             result_type := base_feature.result_type;
  279.             if arguments = Void then
  280.                result_type := result_type.to_runnable(current_type);
  281.             elseif result_type.is_like_argument then
  282.                if not arguments.is_runnable(current_type) then
  283.                   !!arguments.with(arguments,current_type);
  284.                end;
  285.                result_type := result_type.to_runnable(current_type);
  286.             else
  287.                result_type := result_type.to_runnable(current_type);
  288.                if not arguments.is_runnable(current_type) then
  289.                   !!arguments.with(arguments,current_type);
  290.                end;
  291.             end;
  292.          end;
  293.          if run_control.require_check then
  294.             require_assertion := run_require;
  295.          end;
  296.          if run_control.ensure_check then
  297.             ensure_assertion := run_ensure;
  298.          end;
  299.          if as_twin = n then
  300.             rf := run_class.get_copy;
  301.          elseif as_se_argc = n then
  302.             type_string.set_at_run_time;
  303.          elseif as_generating_type = n then
  304.             run_control.set_generator_used;
  305.             run_control.set_generating_type_used;
  306.          elseif as_generator = n then
  307.             run_control.set_generator_used;
  308.          elseif as_deep_twin = n then
  309.             run_control.set_deep_twin_used;
  310.         rf := type_any.run_class.get_feature_with(as_deep_clone);
  311.          elseif as_is_deep_equal = n then
  312.             run_control.set_is_deep_equal_used;
  313.          elseif as_exception = n then
  314.             exceptions_handler.set_used;
  315.          elseif as_signal_number = n then
  316.             exceptions_handler.set_used;
  317.          elseif n.has_prefix(fz_basic_) then
  318.             small_eiffel.register_sys_runtime_basic_of(n);
  319.          end;
  320.       end;
  321.  
  322.    compute_use_current is
  323.       do
  324.          if base_feature.use_current then
  325.             use_current_state := ucs_true;
  326.          else
  327.             std_compute_use_current;
  328.          end;
  329.       end;
  330.  
  331.    compute_stupid_switch(r: ARRAY[RUN_CLASS]) is
  332.       do
  333.          if base_feature.native.stupid_switch_function(r,name.to_string) then
  334.             stupid_switch_state := ucs_true;
  335.          else
  336.             stupid_switch_state := ucs_false;
  337.          end;
  338.       end;
  339.  
  340.    update_tmp_jvm_descriptor is
  341.       do
  342.          routine_update_tmp_jvm_descriptor;
  343.       end;
  344.  
  345.    stupid_switch_comment: STRING is "SSERRF8";
  346.  
  347. end -- RUN_FEATURE_8
  348.